function parametros = parametros ()

% Se puede alterar el valor de la semilla para generar distintos valores de pesos.
rand('seed', 131);

x =  [-pi:0.1:pi];

m = length(x);

for i=1:m
	entrenamiento(i,1) = -1;
	entrenamiento(i,2) = x(i);
	respuestas(i) = (sin(x(i)));%*(x(i)^3))+(x(i)/2);
	%respuestas(i) = respuestas(i)/100000;
end

respuestas = respuestas';

neuronas_por_capa=[1 20 30 1];

cantn = length(neuronas_por_capa);
pesos = cell(cantn, 1);
delta_pesos_anterior = cell(cantn, 1);

pesos{1} = [];

for i = 2 : cantn 
    pesos{i} = rand(neuronas_por_capa(i),neuronas_por_capa(i - 1)+1)-0.5;
	pesos{i} = pesos{i}./100
    delta_pesos_anterior{i} = zeros(neuronas_por_capa(i),neuronas_por_capa(i - 1)+1);
end

b=1;
eta=0.1;
[cant_patrones,cols_por_patron] = size(entrenamiento);
errorAnt=globalerror = bitmax;
epocas = 0;
cant_capas = length(neuronas_por_capa);

while (globalerror > 10e-1 && epocas<70)

    epocas = epocas+1;
    indexes = randperm(cant_patrones);
	
	for mu=1:cant_patrones
        % paso 2 (se elige un patron y se lo aplica a la capa de entrada)
        V = cell(cant_capas, 1);
        h = cell(cant_capas, 1);
        delta = cell(cant_capas, 1);
        V{1} = entrenamiento(indexes(mu),:);

        for m=2:cant_capas
            neuronas_capa = neuronas_por_capa(m);
            V{m} = zeros(1, neuronas_capa + 1);
            h{m} = zeros(1, neuronas_capa + 1);
            delta{m} = zeros(1, neuronas_capa + 1);

            V{m}(1) = -1;
            if m == cant_capas                          %Aplicamos la funcion lineal para la ultima capa.
                h{m}(2) = sum(pesos{m}(1,:) .* V{m-1});
                V{m}(2) = b * h{m}(2);
				V{m}(2)
            else
                for i = 2 : neuronas_capa + 1
                    h{m}(i) = sum(pesos{m}(i-1,:) .* V{m-1});
                    V{m}(i) = tanh(b.*(h{m}(i)));
					V{m}(i)
                end
            end
        end
			
        M = cant_capas;
        aux = respuestas(indexes(mu)) - V{M}(2);        % por que hay un -1s
        delta{M}(2) = b * aux;
		
        % paso 5 (se propagan hacia atras los deltas)
        for m = M-1:-1:2
            neuronas_capa = neuronas_por_capa(m);
            neu_capa_anterior = neuronas_por_capa(m+1);
            for i = 2 : neuronas_capa + 1
                acum = 0;
                for j = 2 : neu_capa_anterior + 1
                    acum = acum + pesos{m+1}(j-1,i) * delta{m+1}(j);    %atencion, el cambio de incide!
                end
                delta{m}(i) = b*(1-(h{m}(i).^2)) * acum; 
            end
        end

        % paso 6 (se actualizan los pesos para todas las capas)
        for m=2:cant_capas
            neuronas_capa = neuronas_por_capa(m);
            neuronas_capa_anterior = neuronas_por_capa(m-1);
            for i=2:neuronas_capa + 1
                for j=1:neuronas_capa_anterior + 1
                    aux_delta = eta * delta{m}(i) * V{m-1}(j);
                    delta_pesos = aux_delta + 0.9 * delta_pesos_anterior{m}(i-1, j);   % Momentum
                    pesos{m}(i -1, j) = pesos{m}(i -1, j) + delta_pesos;
                    delta_pesos_anterior{m}(i -1, j) = aux_delta;
                end
            end
        end

        err_patron(indexes(mu)) = (respuestas(indexes(mu)) - V{M}(2))^2;
        resp(indexes(mu)) = V{M}(2);
	end
	epocas
	globalerror = sum(err_patron)/2
	fflush(1);
%	if(globalerror<errorAnt)
%		%cantAciertos=cantAciertos+1;
%		eta=eta+0.01;
%	else
%		eta=eta*0.9;
%	end
%	errorAnt=globalerror;
	plot(x, respuestas, entrenamiento(:, 2), resp);
	drawnow;
end

plot(entrenamiento(:, 2), resp);
